package com.gljx.util;

import com.gljx.constant.ActivitiKey;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by Administrator on 2018/2/5 0005.
 * 用于流程同样的流程的公共类
 */
public class Axamine {

    //导入activiti工具
    ActitiviUtil activitiUtil = new ActitiviUtil();

    /**
     * @Author lcx
     * @Date 2018/2/5 0005 上午 9:37
     * 传入 单据编号 如果成功则返回 SUCCESS(1, "SUCCESS"),
     */
    public ServerResponse submissionProcess(String fnumber, String auditState) {
        if (!Boolean.valueOf(auditState)) {
            //2.将这个单据编号和你需要保存的流程变量存入map集合中
            Map<String, Object> map = new HashMap<String, Object>();

            map.put(ActivitiKey.PUBLIC_PROCESS, fnumber);//使用你自己单据的key，或者用默认的
            /*com.gljx.constant.ActivitiKey 中存入流程相关的常量，最好将流程定义的key也存入其中*/

            //3.调用方法
            String piID = activitiUtil.creatFlow(
                    ActivitiKey.PUBLIC_PROCESS,  //指定要启动的流程定义
                    map                     //流程变量
            );
            //4.如果你有“提交”这个流程，那么你还要补上一步，将流程推进到提交的下一步
            activitiUtil.completeFlowByPiID(piID);
        } else {
            activitiUtil.complteFlowByVariable(
                    ActivitiKey.PUBLIC_PROCESS,  //指定要启动的流程定义
                    fnumber                    //流程变量
            );
        }
        return ServerResponse.createBySuccessMessage("提交成功！");
    }

    /**
     *rhc
     * @param fnumber
     * @param auditState
     * @param activityKey
     * @return
     */
    public ServerResponse subminssionProcess(String fnumber,String auditState,String activityKey){
       if(!Boolean.valueOf(auditState)){
           //2.将这个单据编号和你需要保存的流程变量存入map集合中
           Map<String, Object> map = new HashMap<String, Object>();

           map.put(activityKey, fnumber);//使用你自己单据的key，或者用默认的
            /*com.gljx.constant.ActivitiKey 中存入流程相关的常量，最好将流程定义的key也存入其中*/

           //3.调用方法
           String piID = activitiUtil.creatFlow(
                   activityKey,  //指定要启动的流程定义
                   map                     //流程变量
           );
           //4.如果你有“提交”这个流程，那么你还要补上一步，将流程推进到提交的下一步
           activitiUtil.completeFlowByPiID(piID);
       } else {
           activitiUtil.complteFlowByVariable(
                   activityKey,  //指定要启动的流程定义
                   fnumber                    //流程变量
           );

       }

        return ServerResponse.createBySuccessMessage("提交成功");
    }

    /**
     * @Author lcx
     * @Date 2018/2/11 0011 上午 10:53
     * 带判断这个流程是不是第一次提交的方法
     */
    public ServerResponse submissionProcess(String fnumber) {

        //2.将这个单据编号和你需要保存的流程变量存入map集合中
        Map<String, Object> map = new HashMap<String, Object>();

        map.put(ActivitiKey.PUBLIC_PROCESS, fnumber);//使用你自己单据的key，或者用默认的
        /*com.gljx.constant.ActivitiKey 中存入流程相关的常量，最好将流程定义的key也存入其中*/

        //2.查询
        String result = activitiUtil.getTaskStateByUser(
                ActivitiKey.PUBLIC_PROCESS, fnumber               //单据
        );

        if (activitiUtil.notTask.equals(result) || activitiUtil.FINISH.equals(result)) {
            System.out.println("改单据没有对应流程");
            //3.调用方法
            String piID = activitiUtil.creatFlow(ActivitiKey.PUBLIC_PROCESS, map);
            activitiUtil.completeFlowByPiID(piID);

            return ServerResponse.createBySuccessMessage("提交成功！");

        } else {

            System.out.println("当前用户可以审核该单据");
            activitiUtil.complteFlowByVariable(ActivitiKey.PUBLIC_PROCESS, fnumber);

            return ServerResponse.createBySuccessMessage("提交成功！");
        }
    }

    /**
     * @Author lcx
     * @Date 2018/2/5 0005 上午 9:39
     * 传入 单据编号 以及批注
     * 返回 0 是错误 1是此流程成功推进，并且此流程已经结束  2 是 此流程成功推进  agreed 1 是同意
     */
    public ServerResponse auditProcess(Object fnumber, String agreed, String auditcomment) {

        if ("1".equals(agreed)) {
            auditcomment = "同意：" + auditcomment;
        } else {
            auditcomment = "不同意：" + auditcomment;
        }
        String returnMsg =
                activitiUtil
                        .auditComplte(
                                ActivitiKey.PUBLIC_PROCESS,
                                fnumber,                  //单据
                                Integer.valueOf(agreed),                 //1、0是否同意取决于你的流程图
                                auditcomment              //批注，直接把前端传过来的string塞进来
                        );

        if (activitiUtil.notAssign.equals(returnMsg)) {
            System.out.println("当前用户不是要求的经办人");
            return ServerResponse.createByErrorMessage("当前用户不是要求的经办人");

        } else if (activitiUtil.FINISH.equals(returnMsg)) {
            System.out.println("此流程成功推进，并且此流程已经结束");
            return ServerResponse.createBySuccessMessage("此流程成功推进，并且此流程已经结束");

        } else if (activitiUtil.SUCCESS.equals(returnMsg)) {
            System.out.println("此流程成功推进");
            return ServerResponse.createByNextMessage("此流程成功推进");
        } else {
            System.out.println("没有找到正在进行的相关流程");
            return ServerResponse.createByErrorMessage("没有找到正在进行的相关流程");
        }

    }

    /**
     * @Author lcx
     * @Date 2018/2/7 0007 下午 2:01
     * 反审核 0 是错误 1是反审核成功
     */
    public ServerResponse againstAuditProcess(Object fnumber, String message) {
        Object result = activitiUtil.jumpActivtiMessage(
                ActivitiKey.PUBLIC_PROCESS,
                fnumber,                  //
                message
        );
        if (activitiUtil.SUCCESS.equals(result)) {
            System.out.println("反审核成功！");
            return ServerResponse.createBySuccessMessage("反审核成功！");
        } else if (activitiUtil.notActiviti.equals(result)) {
            System.out.println("找不到流程节点");
            return ServerResponse.createByErrorMessage("找不到流程节点");

        } else {
            System.out.println("没有找到任务");
            return ServerResponse.createByErrorMessage("没有找到任务");
        }
    }

    /**
     * @Author lcx
     * @Date 2018/2/7 0007 下午 2:05
     * 查询经办人是否匹配
     */
    public boolean selectAuditPerson(Object fnumber) {

        //2.查询
        String result = activitiUtil.getTaskStateByUser(
                ActivitiKey.PUBLIC_PROCESS,
                fnumber                  //单据
        );

        if (activitiUtil.notTask.equals(result)) {
            System.out.println("改单据没有对应流程");
            return false;
        } else if (activitiUtil.FINISH.equals(result)) {
            System.out.println("流程已结束");
            return false;
        }//剩下两种是该任务进行中
        else if (activitiUtil.notAssign.equals(result)) {
            System.out.println("经办人不匹配");
            return false;
        } else if (activitiUtil.ISPOWER.equals(result)) {
            System.out.println("当前用户可以审核该单据");
            return true;
        } else {
            return false;
        }
    }

    /**
     * @Author lcx
     * @Date 2018/2/7 0007 下午 2:05
     * 查询经办人是否匹配
     */
    public boolean selectAuditPersonByAdd(Object fnumber) {

        //2.查询
        String result = activitiUtil.getTaskStateByUser(
                "key",
                fnumber                  //单据
        );

        if (activitiUtil.notTask.equals(result)) {
            System.out.println("改单据没有对应流程");
            return false;
        } else if (activitiUtil.FINISH.equals(result)) {
            System.out.println("流程已结束");
            return false;
        }//剩下两种是该任务进行中
        else if (activitiUtil.notAssign.equals(result)) {
            System.out.println("经办人不匹配");
            return false;
        } else if (activitiUtil.ISPOWER.equals(result)) {
            System.out.println("当前用户可以审核该单据");
            return true;
        } else {
            return false;
        }
    }

    /**
     * @Author lcx
     * @Date 2018/2/7 0007 下午 2:05
     * 查询经办人是否匹配
     */
    public String selectAuditPersonByAdd(String fnumber, String key) {

        //2.查询
        String result = activitiUtil.getTaskStateByUser(
                key,
                fnumber                  //单据
        );

        if (activitiUtil.notTask.equals(result)) {
            System.out.println("改单据没有对应流程");
            return "false";
        } else if (activitiUtil.FINISH.equals(result)) {
            System.out.println("流程已结束");
            return "endTrue";
        }//剩下两种是该任务进行中
        else if (activitiUtil.notAssign.equals(result)) {
            System.out.println("经办人不匹配");
            return "false";
        } else if (activitiUtil.ISPOWER.equals(result)) {
            System.out.println("当前用户可以审核该单据");
            return "true";
        } else {
            return "false";
        }
    }

    /**
     * @Author lcx
     * @Date 2018/2/7 0007 下午 2:05
     * 查询经办人是否匹配
     */
    public Boolean selectAuditPersonByAdd(Object fnumber, String key) {
        //2.查询
        String result = activitiUtil.getTaskStateByUser(
                key,
                fnumber                  //单据
        );

        if (activitiUtil.notTask.equals(result)) {
            System.out.println("改单据没有对应流程");
            return false;
        } else if (activitiUtil.FINISH.equals(result)) {
            System.out.println("流程已结束");
            return true;
        }//剩下两种是该任务进行中
        else if (activitiUtil.notAssign.equals(result)) {
            System.out.println("经办人不匹配");
            return false;
        } else if (activitiUtil.ISPOWER.equals(result)) {
            System.out.println("当前用户可以审核该单据");
            return true;
        } else {
            return false;
        }
    }
}
